/**
 * 视频下载器 - 客户端媒体资源检测与下载功能
 * 参考cat-catch项目实现
 */

// 全局变量
let detectedMedia = [];
let mediaFilter = "";

/**
 * 验证字符串是否为有效URL
 * @param {string} str - 要验证的字符串
 * @returns {boolean} 是否为有效URL
 */
function isValidUrl(str) {
    try {
        new URL(str);
        return true;
    } catch (e) {
        return false;
    }
}

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    // 初始化Feather图标
    if (typeof feather !== 'undefined') {
        feather.replace();
    }
    
    // 绑定按钮事件
    console.log('[调试] 页面加载完成，开始绑定按钮事件');
    setTimeout(function() {
        bindEvents();
        console.log('[调试] 按钮事件绑定完成');
    }, 500); // 延迟500毫秒确保DOM完全加载
});

/**
 * 绑定页面事件
 */
function bindEvents() {
    console.log('[调试] 开始绑定按钮事件');
    
    // 统一解析功能按钮
    const analyzeBtn = document.getElementById('analyzeBtn');
    if (analyzeBtn) {
        console.log('[调试] 找到解析按钮，绑定点击事件');
        // 使用事件委托，避免多次绑定
        analyzeBtn.onclick = function(event) {
            event.preventDefault();
            const input = document.getElementById('pageUrl').value.trim();
            console.log('[调试] 解析按钮被点击，输入内容：', input);
            if (!input) {
                console.warn('[警告] 输入内容为空');
                return showError('请输入内容');
            }
            
            if (isValidUrl(input)) {
                console.log('[调试] 开始解析URL：', input);
                analyzeUrl(input);
            } else {
                console.log('[调试] 执行当前页面检测');
                showLoading('正在检测当前页面视频...');
                detectMediaInPage(window.location.href);
            }
        };
    } else {
        console.warn('[警告] 未找到解析按钮');
    }
    
    // 媒体筛选输入框
    const mediaFilter = document.getElementById('mediaFilter');
    if (mediaFilter) {
        console.log('[调试] 找到媒体筛选输入框，绑定输入事件');
        mediaFilter.oninput = function() {
            filterMedia(this.value);
        };
    }
    
    // 清除筛选按钮
    const clearFilterBtn = document.getElementById('clearFilterBtn');
    if (clearFilterBtn) {
        console.log('[调试] 找到清除筛选按钮，绑定点击事件');
        clearFilterBtn.onclick = function(event) {
            event.preventDefault();
            document.getElementById('mediaFilter').value = '';
            filterMedia('');
        };
    }
    
    // YouTube下载按钮
    const youtubeDownloadBtn = document.getElementById('youtubeDownloadBtn');
    if (youtubeDownloadBtn) {
        console.log('[调试] 找到YouTube下载按钮，绑定点击事件');
        youtubeDownloadBtn.onclick = function(event) {
            event.preventDefault();
            const youtubeUrl = document.getElementById('youtubeUrl').value.trim();
            const withSubtitles = document.getElementById('youtubeWithSubtitles').checked;
            if (youtubeUrl) {
                downloadYouTubeVideo(youtubeUrl, withSubtitles);
            } else {
                showError('请输入有效的YouTube视频URL');
            }
        };
    } else {
        console.warn('[警告] 未找到YouTube下载按钮');
    }
    
    // Bilibili下载按钮
    const bilibiliDownloadBtn = document.getElementById('bilibiliDownloadBtn');
    if (bilibiliDownloadBtn) {
        console.log('[调试] 找到Bilibili下载按钮，绑定点击事件');
        bilibiliDownloadBtn.onclick = function(event) {
            event.preventDefault();
            const bilibiliUrl = document.getElementById('bilibiliUrl').value.trim();
            const withDanmaku = document.getElementById('bilibiliWithDanmaku').checked;
            if (bilibiliUrl) {
                downloadBilibiliVideo(bilibiliUrl, withDanmaku);
            } else {
                showError('请输入有效的Bilibili视频URL');
            }
        };
    } else {
        console.warn('[警告] 未找到Bilibili下载按钮');
    }
    
    // 上传Cookies按钮
    const uploadCookiesBtn = document.getElementById('uploadCookiesBtn');
    if (uploadCookiesBtn) {
        console.log('[调试] 找到上传Cookies按钮，绑定点击事件');
        uploadCookiesBtn.onclick = function(event) {
            event.preventDefault();
            const cookiesFile = document.getElementById('cookiesFile').files[0];
            if (cookiesFile) {
                uploadBilibiliCookies(cookiesFile);
            } else {
                showError('请选择cookies文件');
            }
        };
    }
    
    console.log('[调试] 按钮事件绑定完成');
}

/**
 * 显示加载中状态
 * @param {string} message - 加载提示信息
 */
function showLoading(message) {
    const resultArea = document.getElementById('resultArea');
    const loadingIndicator = document.getElementById('loadingIndicator');
    const loadingText = loadingIndicator.querySelector('.loading-text');
    
    // 隐藏其他提示
    document.getElementById('errorAlert').style.display = 'none';
    document.getElementById('successAlert').style.display = 'none';
    
    // 显示加载提示
    loadingText.textContent = message || '正在处理，请稍候...';
    loadingIndicator.style.display = 'block';
    resultArea.style.display = 'block';
}

/**
 * 显示错误信息
 * @param {string} message - 错误信息
 */
function showError(message) {
    const resultArea = document.getElementById('resultArea');
    const errorAlert = document.getElementById('errorAlert');
    
    // 隐藏其他提示
    document.getElementById('loadingIndicator').style.display = 'none';
    document.getElementById('successAlert').style.display = 'none';
    
    // 显示错误提示
    errorAlert.textContent = message;
    errorAlert.style.display = 'block';
    resultArea.style.display = 'block';
}

/**
 * 显示成功信息
 * @param {string} message - 成功信息
 */
function showSuccess(message) {
    const resultArea = document.getElementById('resultArea');
    const successAlert = document.getElementById('successAlert');
    
    // 隐藏其他提示
    document.getElementById('loadingIndicator').style.display = 'none';
    document.getElementById('errorAlert').style.display = 'none';
    
    // 显示成功提示
    successAlert.textContent = message;
    successAlert.style.display = 'block';
    resultArea.style.display = 'block';
}

/**
 * 解析URL获取媒体资源
 * @param {string} url - 网页URL
 */
function analyzeUrl(url) {
    console.log('[调试] 发起解析请求，URL：', url);
    showLoading('正在解析网页媒体资源，请稍候...');
    
    // 首先尝试使用通用下载API获取视频信息
    fetch(`/api/video-downloader/download?url=${encodeURIComponent(url)}`)
    .then(response => {
        console.log('[调试] 收到响应，状态码：', response.status);
        return response.json();
    })
    .then(data => {
        if (data.success) {
            // 显示视频信息
            console.log('[调试] 解析成功，视频标题：', data.title);
            showSuccess(`获取视频信息成功: ${data.title}`);
            
            // 创建下载按钮
            createDownloadButton(data.url, data.type, false, data.title);
        } else {
            // 如果通用下载失败，尝试使用旧的解析API
            console.log('[调试] 通用下载失败，尝试使用解析API');
            fallbackToAnalyzeApi(url);
        }
    })
    .catch(error => {
        console.error('[错误] 请求异常：', error);
        // 如果出错，尝试使用旧的解析API
        fallbackToAnalyzeApi(url);
    });
}

/**
 * 回退到旧的解析API
 * @param {string} url - 网页URL
 */
function fallbackToAnalyzeApi(url) {
    showLoading('正在使用备用方式解析媒体资源，请稍候...');
    
    fetch('/api/video-downloader/analyze', {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({ url: url })
    })
    .then(response => {
        console.log('[调试] 收到响应，状态码：', response.status);
        return response.json();
    })
    .then(data => {
        if (data.success) {
            console.log('[调试] 解析成功，找到媒体数量：', data.media?.length || 0);
            showSuccess('解析成功');
            if (data.media && data.media.length > 0) {
                displayMediaResources(data.media);
            } else {
                showError('未检测到媒体资源');
            }
        } else {
            showError(data.message || '解析失败，请检查URL是否正确');
        }
    })
    .catch(error => {
        console.error('[错误] 请求异常：', error);
        showError('请求出错，请稍后重试');
    });
}

/**
 * 在页面中检测媒体资源
 * @param {string} url - 网页URL
 */
function detectMediaInPage(url) {
    showLoading('正在检测页面媒体资源，请稍候...');
    
    // 创建一个隐藏的iframe来加载目标页面
    const iframe = document.createElement('iframe');
    iframe.style.display = 'none';
    iframe.src = url;
    
    // 设置超时，避免长时间加载
    const timeout = setTimeout(() => {
        document.body.removeChild(iframe);
        showError('页面加载超时，请检查URL是否正确');
    }, 30000); // 30秒超时
    
    // iframe加载完成后执行检测
    iframe.onload = function() {
        clearTimeout(timeout);
        try {
            // 尝试访问iframe内容，可能会因为跨域限制而失败
            const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
            const mediaElements = [];
            
            // 收集视频元素
            const videos = iframeDoc.querySelectorAll('video');
            videos.forEach(video => {
                if (video.src) {
                    mediaElements.push({
                        type: 'video',
                        url: video.src,
                        format: getFileExtension(video.src) || 'unknown',
                        size: 'unknown',
                        quality: video.videoHeight ? `${video.videoWidth}x${video.videoHeight}` : 'unknown'
                    });
                }
                
                // 检查video元素的source子元素
                const sources = video.querySelectorAll('source');
                sources.forEach(source => {
                    if (source.src) {
                        mediaElements.push({
                            type: 'video',
                            url: source.src,
                            format: getFileExtension(source.src) || source.type.split('/')[1] || 'unknown',
                            size: 'unknown',
                            quality: 'unknown'
                        });
                    }
                });
            });
            
            // 收集音频元素
            const audios = iframeDoc.querySelectorAll('audio');
            audios.forEach(audio => {
                if (audio.src) {
                    mediaElements.push({
                        type: 'audio',
                        url: audio.src,
                        format: getFileExtension(audio.src) || 'unknown',
                        size: 'unknown',
                        quality: 'unknown'
                    });
                }
                
                // 检查audio元素的source子元素
                const sources = audio.querySelectorAll('source');
                sources.forEach(source => {
                    if (source.src) {
                        mediaElements.push({
                            type: 'audio',
                            url: source.src,
                            format: getFileExtension(source.src) || source.type.split('/')[1] || 'unknown',
                            size: 'unknown',
                            quality: 'unknown'
                        });
                    }
                });
            });
            
            // 移除iframe
            document.body.removeChild(iframe);
            
            // 显示检测到的媒体资源
            if (mediaElements.length > 0) {
                detectedMedia = mediaElements;
                displayMediaResources(mediaElements);
                showSuccess(`检测到 ${mediaElements.length} 个媒体资源`);
            } else {
                // 如果没有直接检测到媒体元素，尝试分析网络请求
                showError('未直接检测到媒体元素，请尝试使用"解析链接"按钮');
            }
        } catch (error) {
            // 可能是因为跨域限制无法访问iframe内容
            document.body.removeChild(iframe);
            console.error('检测媒体出错:', error);
            showError('由于跨域限制，无法直接检测页面媒体。请尝试使用"解析链接"按钮');
        }
    };
    
    // 添加iframe到页面
    document.body.appendChild(iframe);
}

/**
 * 获取文件扩展名
 * @param {string} url - 文件URL
 * @returns {string} 文件扩展名
 */
function getFileExtension(url) {
    try {
        const urlObj = new URL(url);
        const pathname = urlObj.pathname;
        const filename = pathname.split('/').pop();
        if (filename.includes('.')) {
            return filename.split('.').pop().toLowerCase();
        }
        return '';
    } catch (e) {
        return '';
    }
}

/**
 * 显示检测到的媒体资源列表
 * @param {Array} mediaList - 媒体资源列表
 */
function displayMediaResources(mediaList) {
    const mediaListContainer = document.getElementById('mediaList');
    const mediaResourcesContainer = document.getElementById('mediaResourcesContainer');
    
    // 清空现有列表
    mediaListContainer.innerHTML = '';
    
    // 显示媒体资源容器
    mediaResourcesContainer.style.display = 'block';
    
    // 创建媒体资源列表
    mediaList.forEach((media, index) => {
        const mediaItem = document.createElement('div');
        mediaItem.className = 'media-item';
        mediaItem.dataset.url = media.url;
        mediaItem.dataset.type = media.type;
        mediaItem.dataset.format = media.format;
        
        // 创建媒体信息
        const mediaInfo = document.createElement('div');
        mediaInfo.className = 'media-info';
        
        // 媒体类型图标
        const typeIcon = document.createElement('i');
        typeIcon.setAttribute('data-feather', media.type === 'video' ? 'video' : 'music');
        mediaInfo.appendChild(typeIcon);
        
        // 媒体格式和质量
        const formatInfo = document.createElement('span');
        formatInfo.className = 'media-format';
        formatInfo.textContent = `${media.format.toUpperCase()} ${media.quality !== 'unknown' ? '| ' + media.quality : ''}`;
        mediaInfo.appendChild(formatInfo);
        
        // 媒体URL（截断显示）
        const urlInfo = document.createElement('span');
        urlInfo.className = 'media-url';
        urlInfo.title = media.url; // 完整URL作为提示
        urlInfo.textContent = truncateUrl(media.url, 60);
        mediaInfo.appendChild(urlInfo);
        
        mediaItem.appendChild(mediaInfo);
        
        // 创建操作按钮
        const mediaActions = document.createElement('div');
        mediaActions.className = 'media-actions';
        
        // 复制链接按钮
        const copyBtn = document.createElement('button');
        copyBtn.className = 'btn btn-sm btn-outline-secondary me-2';
        copyBtn.innerHTML = '<i data-feather="copy"></i> 复制链接';
        copyBtn.addEventListener('click', function() {
            navigator.clipboard.writeText(media.url)
                .then(() => {
                    this.innerHTML = '<i data-feather="check"></i> 已复制';
                    feather.replace();
                    setTimeout(() => {
                        this.innerHTML = '<i data-feather="copy"></i> 复制链接';
                        feather.replace();
                    }, 2000);
                })
                .catch(err => {
                    console.error('复制失败:', err);
                });
        });
        mediaActions.appendChild(copyBtn);
        
        // 下载按钮
        const downloadBtn = document.createElement('button');
        downloadBtn.className = 'btn btn-sm btn-primary';
        downloadBtn.innerHTML = '<i data-feather="download"></i> 下载';
        downloadBtn.addEventListener('click', function() {
            downloadMedia(media.url, getFileNameFromUrl(media.url));
        });
        mediaActions.appendChild(downloadBtn);
        
        mediaItem.appendChild(mediaActions);
        
        // 添加到列表
        mediaListContainer.appendChild(mediaItem);
    });
    
    // 初始化Feather图标
    if (typeof feather !== 'undefined') {
        feather.replace();
    }
}

/**
 * 截断URL显示
 * @param {string} url - 完整URL
 * @param {number} maxLength - 最大显示长度
 * @returns {string} 截断后的URL
 */
function truncateUrl(url, maxLength) {
    if (url.length <= maxLength) {
        return url;
    }
    
    try {
        const urlObj = new URL(url);
        const domain = urlObj.hostname;
        const path = urlObj.pathname;
        
        // 保留域名和路径的一部分
        const halfLength = Math.floor((maxLength - 3) / 2); // 减去省略号的长度
        return domain + path.substring(0, halfLength) + '...' + path.substring(path.length - halfLength);
    } catch (e) {
        // 如果URL解析失败，简单截断
        return url.substring(0, maxLength / 2) + '...' + url.substring(url.length - maxLength / 2);
    }
}

/**
 * 从URL中获取文件名
 * @param {string} url - 文件URL
 * @returns {string} 文件名
 */
function getFileNameFromUrl(url) {
    try {
        const urlObj = new URL(url);
        const pathname = urlObj.pathname;
        let filename = pathname.split('/').pop();
        
        // 如果没有文件名或文件名没有扩展名，生成一个默认文件名
        if (!filename || !filename.includes('.')) {
            const ext = getMediaTypeFromUrl(url);
            const timestamp = new Date().getTime();
            filename = `media_${timestamp}.${ext}`;
        }
        
        // 解码URL编码的文件名
        try {
            return decodeURIComponent(filename);
        } catch (e) {
            return filename;
        }
    } catch (e) {
        // URL解析失败，生成默认文件名
        const timestamp = new Date().getTime();
        return `media_${timestamp}.mp4`;
    }
}

/**
 * 从URL猜测媒体类型
 * @param {string} url - 媒体URL
 * @returns {string} 媒体类型扩展名
 */
function getMediaTypeFromUrl(url) {
    const ext = getFileExtension(url);
    if (ext) return ext;
    
    // 根据URL中的关键词猜测媒体类型
    const lowerUrl = url.toLowerCase();
    if (lowerUrl.includes('video') || lowerUrl.includes('mp4') || lowerUrl.includes('m3u8')) {
        return 'mp4';
    } else if (lowerUrl.includes('audio') || lowerUrl.includes('mp3')) {
        return 'mp3';
    } else {
        return 'mp4'; // 默认视频类型
    }
}

/**
 * 下载媒体文件
 * @param {string} url - 媒体URL
 * @param {string} filename - 文件名
 */
function downloadMedia(url, filename) {
    // 创建一个隐藏的a标签用于下载
    const a = document.createElement('a');
    a.style.display = 'none';
    a.href = url;
    a.download = filename;
    document.body.appendChild(a);
    
    // 触发点击事件开始下载
    a.click();
    
    // 移除a标签
    setTimeout(() => {
        document.body.removeChild(a);
    }, 100);
}

/**
 * 筛选媒体列表
 * @param {string} keyword - 筛选关键词
 */
function filterMedia(keyword) {
    mediaFilter = keyword.toLowerCase();
    const mediaItems = document.querySelectorAll('.media-item');
    
    mediaItems.forEach(item => {
        const url = item.dataset.url.toLowerCase();
        const type = item.dataset.type.toLowerCase();
        const format = item.dataset.format.toLowerCase();
        
        if (!mediaFilter || 
            url.includes(mediaFilter) || 
            type.includes(mediaFilter) || 
            format.includes(mediaFilter)) {
            item.style.display = 'flex';
        } else {
            item.style.display = 'none';
        }
    });
}

/**
 * 下载YouTube视频
 * @param {string} url - YouTube视频URL
 * @param {boolean} withSubtitles - 是否下载字幕
 */
function downloadYouTubeVideo(url, withSubtitles) {
    showLoading('正在获取YouTube视频信息，请稍候...');
    
    fetch('/api/video-downloader/youtube', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
            url: url,
            subtitles: withSubtitles
        })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            // 显示视频信息
            showSuccess(`获取视频信息成功: ${data.title}`);
            
            // 创建下载按钮
            createDownloadButton(data.url, 'youtube', withSubtitles, data.title);
        } else {
            showError(data.message || 'YouTube视频信息获取失败');
        }
    })
    .catch(error => {
        console.error('YouTube信息请求出错:', error);
        showError('请求出错，请稍后重试');
    });
}

/**
 * 下载Bilibili视频
 * @param {string} url - Bilibili视频URL
 * @param {boolean} withDanmaku - 是否下载弹幕
 */
function downloadBilibiliVideo(url, withDanmaku) {
    showLoading('正在获取Bilibili视频信息，请稍候...');
    
    fetch('/api/video-downloader/bilibili', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
            url: url,
            danmaku: withDanmaku
        })
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            // 显示视频信息
            showSuccess(`获取视频信息成功: ${data.title}`);
            
            // 创建下载按钮
            createDownloadButton(data.url, 'bilibili', withDanmaku, data.title);
        } else {
            showError(data.message || 'Bilibili视频信息获取失败');
        }
    })
    .catch(error => {
        console.error('Bilibili信息请求出错:', error);
        showError('请求出错，请稍后重试');
    });
}

/**
 * 创建下载按钮
 * @param {string} url - 视频URL
 * @param {string} type - 视频类型 (youtube/bilibili)
 * @param {boolean} withOption - 是否下载字幕/弹幕
 * @param {string} title - 视频标题
 */
function createDownloadButton(url, type, withOption, title) {
    // 获取结果区域
    const resultArea = document.getElementById('resultArea');
    
    // 创建下载信息区域
    const downloadInfo = document.createElement('div');
    downloadInfo.className = 'alert alert-info mt-3';
    downloadInfo.innerHTML = `
        <h6>视频信息</h6>
        <p><strong>标题:</strong> ${title}</p>
        <p><strong>类型:</strong> ${type === 'youtube' ? 'YouTube' : 'Bilibili'}</p>
        <p><strong>选项:</strong> ${type === 'youtube' ? (withOption ? '下载字幕' : '不下载字幕') : (withOption ? '下载弹幕' : '不下载弹幕')}</p>
        <div class="progress mb-3" style="display:none;">
            <div class="progress-bar progress-bar-striped progress-bar-animated" role="progressbar" style="width: 0%"></div>
        </div>
        <div class="download-status"></div>
        <button class="btn btn-primary start-download-btn">
            <i data-feather="download"></i> 开始下载到本地
        </button>
    `;
    
    // 添加到结果区域
    resultArea.appendChild(downloadInfo);
    
    // 初始化Feather图标
    if (typeof feather !== 'undefined') {
        feather.replace();
    }
    
    // 绑定下载按钮事件
    const downloadBtn = downloadInfo.querySelector('.start-download-btn');
    downloadBtn.addEventListener('click', function() {
        startStreamDownload(url, type, withOption, downloadInfo);
    });
}

/**
 * 开始流式下载
 * @param {string} url - 视频URL
 * @param {string} type - 视频类型
 * @param {boolean} withOption - 是否下载字幕/弹幕
 * @param {HTMLElement} infoElement - 信息显示元素
 */
function startStreamDownload(url, type, withOption, infoElement) {
    // 获取进度条和状态显示元素
    const progressBar = infoElement.querySelector('.progress');
    const progressBarInner = infoElement.querySelector('.progress-bar');
    const statusElement = infoElement.querySelector('.download-status');
    const downloadBtn = infoElement.querySelector('.start-download-btn');
    
    // 显示进度条，禁用下载按钮
    progressBar.style.display = 'block';
    downloadBtn.disabled = true;
    downloadBtn.innerHTML = '<i data-feather="loader"></i> 下载中...';
    if (typeof feather !== 'undefined') {
        feather.replace();
    }
    
    // 构建查询参数
    const params = new URLSearchParams();
    params.append('url', url);
    params.append('type', type);
    
    if (type === 'youtube') {
        params.append('subtitles', withOption);
    } else if (type === 'bilibili') {
        params.append('danmaku', withOption);
    }
    
    // 创建EventSource连接
    const eventSource = new EventSource(`/api/video-downloader/stream-download?${params.toString()}`);
    
    // 监听消息事件
    eventSource.onmessage = function(event) {
        try {
            const data = JSON.parse(event.data);
            console.log('下载进度更新:', data);
            
            // 根据状态更新UI
            switch(data.status) {
                case 'start':
                    updateProgress(0, '开始下载...', progressBarInner, statusElement);
                    break;
                    
                case 'downloading':
                    if (data.progress) {
                        updateProgress(data.progress, data.message || '下载中...', progressBarInner, statusElement);
                    }
                    break;
                    
                case 'merging':
                    updateProgress(95, '正在合并视频和音频...', progressBarInner, statusElement);
                    break;
                    
                case 'merged':
                    updateProgress(98, '视频和音频合并成功', progressBarInner, statusElement);
                    break;
                    
                case 'merge_failed':
                    updateProgress(98, '视频和音频合并失败，将下载原始文件', progressBarInner, statusElement);
                    break;
                    
                case 'complete':
                    updateProgress(100, `下载完成: ${data.file_name}`, progressBarInner, statusElement);
                    break;
                    
                case 'ready':
                    // 下载文件
                    const downloadLink = document.createElement('a');
                    downloadLink.href = data.download_url;
                    downloadLink.download = data.file_name;
                    downloadLink.className = 'btn btn-success mt-2';
                    downloadLink.innerHTML = '<i data-feather="download"></i> 保存文件';
                    statusElement.appendChild(downloadLink);
                    
                    if (typeof feather !== 'undefined') {
                        feather.replace();
                    }
                    
                    // 自动点击下载
                    downloadLink.click();
                    
                    // 关闭事件源
                    eventSource.close();
                    
                    // 更新按钮状态
                    downloadBtn.disabled = false;
                    downloadBtn.innerHTML = '<i data-feather="refresh-cw"></i> 重新下载';
                    if (typeof feather !== 'undefined') {
                        feather.replace();
                    }
                    break;
                    
                case 'error':
                    updateProgress(0, `错误: ${data.message}`, progressBarInner, statusElement, true);
                    eventSource.close();
                    
                    // 更新按钮状态
                    downloadBtn.disabled = false;
                    downloadBtn.innerHTML = '<i data-feather="refresh-cw"></i> 重试';
                    if (typeof feather !== 'undefined') {
                        feather.replace();
                    }
                    break;
                    
                case 'heartbeat':
                    // 心跳包，不做处理
                    break;
                    
                case 'end':
                    // 流结束
                    eventSource.close();
                    break;
            }
        } catch (e) {
            console.error('解析进度数据出错:', e);
        }
    };
    
    // 监听错误事件
    eventSource.onerror = function(error) {
        console.error('EventSource错误:', error);
        updateProgress(0, '连接中断，请重试', progressBarInner, statusElement, true);
        eventSource.close();
        
        // 更新按钮状态
        downloadBtn.disabled = false;
        downloadBtn.innerHTML = '<i data-feather="refresh-cw"></i> 重试';
        if (typeof feather !== 'undefined') {
            feather.replace();
        }
    };
}

/**
 * 更新进度条和状态信息
 * @param {number} progress - 进度百分比
 * @param {string} message - 状态消息
 * @param {HTMLElement} progressBar - 进度条元素
 * @param {HTMLElement} statusElement - 状态显示元素
 * @param {boolean} isError - 是否为错误状态
 */
function updateProgress(progress, message, progressBar, statusElement, isError = false) {
    // 更新进度条
    progressBar.style.width = `${progress}%`;
    progressBar.setAttribute('aria-valuenow', progress);
    
    // 如果是错误状态，改变进度条颜色
    if (isError) {
        progressBar.classList.remove('bg-primary');
        progressBar.classList.add('bg-danger');
    } else {
        progressBar.classList.remove('bg-danger');
        progressBar.classList.add('bg-primary');
    }
    
    // 更新状态消息
    statusElement.innerHTML = `<p class="${isError ? 'text-danger' : ''}">${message}</p>`;
}

/**
 * 上传Bilibili Cookies文件
 * @param {File} file - Cookies文件
 */
function uploadBilibiliCookies(file) {
    showLoading('正在上传Cookies文件，请稍候...');
    
    const formData = new FormData();
    formData.append('file', file);
    
    fetch('/api/video-downloader/upload-cookies', {
        method: 'POST',
        body: formData
    })
    .then(response => response.json())
    .then(data => {
        if (data.success) {
            showSuccess(data.message || 'Cookies上传成功');
        } else {
            showError(data.message || 'Cookies上传失败');
        }
    })
    .catch(error => {
        console.error('Cookies上传请求出错:', error);
        showError('请求出错，请稍后重试');
    });
}

/**
 * 修复按钮状态（用于解决按钮无响应问题）
 */
function debugButtonStatus() {
    console.log('[调试] 执行按钮修复函数');
    
    // 输出当前按钮状态，帮助调试
    const analyzeBtn = document.getElementById('analyzeBtn');
    const youtubeDownloadBtn = document.getElementById('youtubeDownloadBtn');
    const bilibiliDownloadBtn = document.getElementById('bilibiliDownloadBtn');
    
    console.log('[调试] 按钮状态检查：', {
        'analyzeBtn': analyzeBtn ? '存在' : '不存在',
        'youtubeDownloadBtn': youtubeDownloadBtn ? '存在' : '不存在',
        'bilibiliDownloadBtn': bilibiliDownloadBtn ? '存在' : '不存在'
    });
    
    // 移除可能存在的旧事件监听器
    if (analyzeBtn) {
        const newAnalyzeBtn = analyzeBtn.cloneNode(true);
        analyzeBtn.parentNode.replaceChild(newAnalyzeBtn, analyzeBtn);
    }
    
    if (youtubeDownloadBtn) {
        const newYoutubeBtn = youtubeDownloadBtn.cloneNode(true);
        youtubeDownloadBtn.parentNode.replaceChild(newYoutubeBtn, youtubeDownloadBtn);
    }
    
    if (bilibiliDownloadBtn) {
        const newBilibiliBtn = bilibiliDownloadBtn.cloneNode(true);
        bilibiliDownloadBtn.parentNode.replaceChild(newBilibiliBtn, bilibiliDownloadBtn);
    }
    
    // 重新绑定所有按钮事件
    setTimeout(function() {
        bindEvents();
        console.log('[调试] 按钮事件重新绑定完成');
    }, 100);
    
    // 重新初始化Feather图标
    if (typeof feather !== 'undefined') {
        feather.replace();
    }
    
    showSuccess('按钮已修复，请重试');
}

// 将debugButtonStatus函数暴露为全局函数，以便HTML中的onclick调用
window.debugButtonStatus = debugButtonStatus;